var api = require('../config/api.js');

function formatTime(date) {
    var year = date.getFullYear()
    var month = date.getMonth() + 1
    var day = date.getDate()

    var hour = date.getHours()
    var minute = date.getMinutes()
    var second = date.getSeconds()


    return [year, month, day].map(formatNumber).join('-') + ' ' + [hour, minute, second].map(formatNumber).join(':')
}

function formatNumber(n) {
    n = n.toString()
    return n[1] ? n : '0' + n
}

/**
 * 封封微信的的request
 */
function request(url, data = {}, method = "POST", header = "application/x-www-form-urlencoded") {
    wx.showLoading({
        title: '加载中...',
    });
    return new Promise(function (resolve, reject) {
        wx.request({
            url: url,
            data: data,
            method: method,
            header: {
                'Content-Type': header,
                'token': wx.getStorageSync('token')
            },
            success: function (res) {
                wx.hideLoading();
                if (res.statusCode == 200) {

                    if (res.data.errno == 401) {
                        wx.navigateTo({
                            url: '/pages/auth/btnAuth/btnAuth',
                        })
                    } else {
                        resolve(res.data);
                    }
                } else {
                    reject(res.errMsg);
                }

            },
            fail: function (err) {
                reject(err)
            }
        })
    });
}

/**
 * 检查微信会话是否过期
 */
function checkSession() {
    return new Promise(function (resolve, reject) {
        wx.checkSession({
            success: function () {
                resolve(true);
            },
            fail: function () {
                reject(false);
            }
        })
    });
}

/**
 * 调用微信登录
 */
function login() {
    return new Promise(function (resolve, reject) {
        wx.login({
            success: function (res) {
                if (res.code) {
                    resolve(res);
                } else {
                    reject(res);
                }
            },
            fail: function (err) {
                reject(err);
            }
        });
    });
}

function redirect(url) {

    //判断页面是否需要登录
    if (false) {
        wx.redirectTo({
            url: '/pages/auth/login/login'
        });
        return false;
    } else {
        wx.redirectTo({
            url: url
        });
    }
}

function showErrorToast(msg) {
    wx.showToast({
        title: msg,
        image: '/static/images/icon_error.png'
    })
}

function showSuccessToast(msg) {
    wx.showToast({
        title: msg,
    })
}

/**
 * 检查用户是否已登录
 * @returns {boolean} 是否已登录
 */
function checkUserLogin() {
    const userInfo = wx.getStorageSync('userInfo')
    const token = wx.getStorageSync('token')
    return !!(userInfo && token)
}

/**
 * 显示登录确认弹窗
 * @param {string} message 提示信息
 * @param {function} onConfirm 确认回调
 * @param {function} onCancel 取消回调
 */
function showLoginModal(message = '此操作需要先登录，是否立即登录？', onConfirm, onCancel) {
    wx.showModal({
        title: '登录提示',
        content: message,
        confirmText: '立即登录',
        cancelText: '取消',
        success: function(res) {
            if (res.confirm) {
                // 用户确认登录
                if (typeof onConfirm === 'function') {
                    onConfirm()
                } else {
                    // 默认跳转到登录页面
                    navigateToLogin()
                }
            } else {
                // 用户取消登录
                if (typeof onCancel === 'function') {
                    onCancel()
                }
            }
        }
    })
}

/**
 * 跳转到登录页面
 * @param {string} returnUrl 登录成功后返回的页面路径
 */
function navigateToLogin(returnUrl = '') {
    // 保存当前页面路径，登录成功后返回
    if (returnUrl) {
        wx.setStorageSync('navUrl', returnUrl)
    } else {
        // 获取当前页面路径
        const pages = getCurrentPages()
        const currentPage = pages[pages.length - 1]
        if (currentPage) {
            wx.setStorageSync('navUrl', '/' + currentPage.route)
        }
    }
    
    wx.navigateTo({
        url: '/pages/auth/btnAuth/btnAuth',
        success: function() {
            console.log('跳转到登录页面成功')
        },
        fail: function() {
            console.log('跳转到登录页面失败')
            wx.showToast({
                title: '页面跳转失败',
                icon: 'none'
            })
        }
    })
}

/**
 * 测试登录API响应格式
 * @param {object} response API响应对象
 * @returns {object} 标准化的响应格式
 */
function normalizeApiResponse(response) {
    console.log('原始API响应:', response);
    
    // 检查不同的响应格式
    if (response.errno !== undefined) {
        // 格式1: { errno: 0, data: {...}, errmsg: "..." }
        return {
            success: response.errno === 0,
            data: response.data,
            message: response.errmsg,
            code: response.errno
        };
    } else if (response.code !== undefined) {
        // 格式2: { code: 200, data: {...}, msg: "..." } - 这是实际使用的格式
        return {
            success: response.code === 200 || response.code === '200' || response.code === 0,
            data: response.data,
            message: response.msg,
            code: response.code
        };
    } else if (response.status !== undefined) {
        // 格式3: { status: "success", data: {...}, message: "..." }
        return {
            success: response.status === 'success' || response.status === 200,
            data: response.data,
            message: response.message,
            code: response.status
        };
    } else {
        // 未知格式，尝试默认处理
        console.warn('未知的API响应格式:', response);
        return {
            success: false,
            data: null,
            message: '未知的响应格式',
            code: -1,
            raw: response
        };
    }
}

/**
 * 带登录校验的操作执行器
 * @param {function} action 需要执行的操作
 * @param {string} loginMessage 登录提示信息
 * @param {string} returnUrl 登录成功后返回的页面路径
 */
function executeWithLoginCheck(action, loginMessage, returnUrl) {
    if (checkUserLogin()) {
        // 用户已登录，直接执行操作
        if (typeof action === 'function') {
            action()
        }
    } else {
        // 用户未登录，显示登录确认弹窗
        showLoginModal(loginMessage, function() {
            navigateToLogin(returnUrl)
        })
    }
}

/**
 * 测试登录API
 * 用于调试和验证API响应格式
 */
function testLoginApi() {
    console.log('开始测试登录API...');
    
    // 获取微信登录code
    login().then((loginRes) => {
        console.log('微信登录code获取成功:', loginRes);
        
        // 模拟用户信息
        const mockUserInfo = {
            nickName: '测试用户',
            avatarUrl: 'https://example.com/avatar.jpg',
            gender: 1,
            country: '中国',
            province: '北京',
            city: '北京'
        };
        
        // 调用登录API
        request(api.AuthLoginByWeixin, {
            code: loginRes.code,
            userInfo: mockUserInfo
        }, 'POST', 'application/json').then((res) => {
            console.log('登录API测试结果:', res);
            
            // 使用标准化处理
            const normalizedRes = normalizeApiResponse(res);
            console.log('标准化后的响应:', normalizedRes);
            
            if (normalizedRes.success) {
                console.log('✅ 登录API测试成功');
                console.log('用户信息:', normalizedRes.data.userInfo);
                console.log('Token:', normalizedRes.data.token);
            } else {
                console.log('❌ 登录API测试失败:', normalizedRes.message);
            }
        }).catch((err) => {
            console.error('❌ 登录API测试请求失败:', err);
        });
    }).catch((err) => {
        console.error('❌ 微信登录code获取失败:', err);
    });
}

/**
 * 比较版本号
 * @param {string} v1 版本号1
 * @param {string} v2 版本号2
 * @returns {number} 1: v1 > v2, 0: v1 = v2, -1: v1 < v2
 */
function compareVersion(v1, v2) {
    v1 = v1.split('.')
    v2 = v2.split('.')
    const len = Math.max(v1.length, v2.length)

    while (v1.length < len) {
        v1.push('0')
    }
    while (v2.length < len) {
        v2.push('0')
    }

    for (let i = 0; i < len; i++) {
        const num1 = parseInt(v1[i])
        const num2 = parseInt(v2[i])

        if (num1 > num2) {
            return 1
        } else if (num1 < num2) {
            return -1
        }
    }

    return 0
}

/**
 * 获取文件URL（处理云存储fileID）
 * 如果是云存储fileID（cloud://开头），需要转换为临时访问链接
 * 适用于头像、图片等所有类型的云存储文件
 * @param {string} fileUrl 文件URL或云存储fileID
 * @returns {Promise<string>} 返回可访问的文件URL
 */
function getFileUrl(fileUrl) {
    return new Promise(function (resolve, reject) {
        // 如果没有文件URL，返回空字符串
        if (!fileUrl || typeof fileUrl !== 'string') {
            resolve('');
            return;
        }

        // 如果不是云存储fileID（cloud://开头），直接返回原URL
        if (!fileUrl.startsWith('cloud://')) {
            resolve(fileUrl);
            return;
        }

        // 如果是云存储fileID，需要转换为临时访问链接
        // 注意：跨账号云环境需要指定 env
        wx.cloud.getTempFileURL({
            fileList: [fileUrl],
            config: {
                env: 'hxq-9gjp5akqf782f714' // 云托管环境ID
            },
            success: function (res) {
                if (res.fileList && res.fileList.length > 0) {
                    const file = res.fileList[0];
                    if (file.tempFileURL) {
                        resolve(file.tempFileURL);
                    } else {
                        console.error('获取临时文件URL失败:', file);
                        resolve(fileUrl); // 失败时返回原fileID，让小程序尝试直接使用
                    }
                } else {
                    console.error('获取临时文件URL失败: 文件列表为空');
                    resolve(fileUrl);
                }
            },
            fail: function (err) {
                console.error('获取临时文件URL失败:', err);
                // 失败时返回原fileID，小程序可能会尝试直接使用
                resolve(fileUrl);
            }
        });
    });
}

/**
 * 同步获取文件URL（简化版，直接使用fileID）
 * 在小程序中，cloud://格式的fileID通常可以直接使用
 * 适用于直接在小程序组件中使用，无需异步转换的场景
 * @param {string} fileUrl 文件URL或云存储fileID
 * @returns {string} 返回文件URL或fileID
 */
function getFileUrlSync(fileUrl) {
    // 如果没有文件URL，返回空字符串（调用方可以使用默认值）
    if (!fileUrl || typeof fileUrl !== 'string') {
        return '';
    }
    
    // 直接返回，包括cloud://格式的fileID
    // 微信小程序原生支持cloud://格式，可以直接在image等组件中使用
    return fileUrl;
}

module.exports = {
    formatTime,
    request,
    redirect,
    showErrorToast,
    showSuccessToast,
    checkSession,
    login,
    compareVersion,
    checkUserLogin,
    showLoginModal,
    navigateToLogin,
    executeWithLoginCheck,
    normalizeApiResponse,
    testLoginApi,
    getFileUrl,
    getFileUrlSync,
    // 保持向后兼容的别名
    getAvatarUrl: getFileUrl,
    getAvatarUrlSync: getFileUrlSync,
}


